#define _CRT_SECURE_NO_WARNINGS 1

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>

using namespace std;

//class Date
//{
//public:
//	/*void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}*/
//
//	Date(){}
//
//	Date(int year, int month, int day) 
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._month;
//	}
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//	bool operator==(const Date& d2)
//	{
//		return _year == d2._year
//			&& _month == d2._month
//			&& _day == d2._day;
//	}
//
//	Date& operator=(const Date& d)
//	{
//		if (this != &d)
//		{
//			_year = d._year;
//			_month = d._month;
//			_day = d._day;
//		}
//		return *this;
//	}
//
//	//前置++;
//	Date& operator++()
//	{
//		_day += 1;
//		return *this;
//	}
//
//	//后置++;
//	Date& operator++(int)
//	{
//		Date tmp(*this);
//		_day += 1;
//		return tmp;
//	}
//
//
//private:
//	int _year;// 年
//	int _month;// 月
//	int _day;// 日
//};

//int main()
//{
//	Date d1, d2;
//	d1.Init(2022, 1, 11);
//	d2.Init(2022, 1, 12);
//	d1.Print();
//	d2.Print();
//	return 0;
//}

//int main()
//{
//	Date d1;
//	Date d2(d1);
//	return 0;
//}



//class A
//{
//public:
//	void Print()
//	{
//		cout << "Print()" << endl;
//	}
//private:
//	int _a;
//};

//int main()
//{
//	A* p = nullptr;
//	p->Print();
//	return 0;
//}

//class A
//{
//public:
//	void PrintA()
//	{
//		cout << _a << endl;
//	}
//private:
//	int _a;
//};

//int main()
//{
//	A* p = nullptr;
//	p->PrintA();
//	return 0;
//}

typedef int DataType;
class Stack
{
public:
	//void Init()
	Stack()
	{
		_array = (DataType*)malloc(sizeof(DataType) * 3);
		if (_array == nullptr)
		{
			cerr << "malloc fail" << endl;
			return;
		}
		_capacity = 3;
		_size = 0;
	}

	void Push(DataType data)
	{
		CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	int Empty()
	{
		return 0 == _size;
	}

	int size() { return _size; }

	DataType Top()
	{
		return _array[_size-1];
	}

	//void Destory()
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = _size = 0;
		}
	}

	void Pop()
	{
		if (Empty())
		{
			return;
		}
		_size--;
	}
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* tmp = (DataType*)realloc(_array, newcapacity * sizeof(DataType));
			if (tmp == nullptr)
			{
				cerr << "realloc fail" << endl;
				return;
			}
			_array = tmp;
			_capacity = newcapacity;
		}
	}

private:
	DataType* _array;
	int _capacity;
	int _size;
};

//int main()
//{
//	Stack s;
//	s.Init();
//	s.Push(1);
//	s.Push(2);
//	s.Push(3);
//	s.Push(4);
//
//	cout << s.Top() << endl;
//	cout << s.size() << endl;
//
//	s.Pop();
//	s.Pop();
//
//	cout << s.Top() << endl;
//	cout << s.size() << endl;
//	s.Destory();
//	return 0;
//}


//int main()
//{
//	Date d;
//	Date d1(2025, 1, 31);
//	d = d1++;
//	d.Print();
//	d = ++d1;
//	d.Print();
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 0, int month = 1, int day = 1) 
//		:_year(year), _month(month), _day(day)
//	{
//		if (year >= 0 && month >= 1 && month <= 12 && day >= 1 && day <= GetMonthDay(year, month))
//		{
//			_year = year;
//			_month = month;
//			_day = day;
//		}
//		else
//		{
//			cout << "日期错误" << endl;
//		}
//	}
//
//	Date(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//
//	int GetMonthDay(int year, int month)
//	{
//		static int monthDays[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
//		if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
//		{
//			return 29;
//		}
//
//		return monthDays[month];
//	}
//
//	bool operator==(const Date& d)
//	{
//		return _year == d._year && _month == d._month && _day == d._day;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};

//class Date
//{
//public:
//	explicit Date(int year)
//		:_year(year)
//	{}
//
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};

//class A
//{
//public:
//	A()
//	{
//		++_count;
//	}
//
//	A(const A& t)
//	{
//		++_count;
//	}
//
//	static int getcount()
//	{
//		return _count;
//	}
//
//	~A()
//	{
//		--_count;
//	}
//private:
//	static int _count;
//};
//
//int A::_count = 0;


//int main()
//{
//	cout << A::getcount() << endl;
//	A a1; A a2;
//	A a3(a1);
//	cout << A::getcount() << endl;
//	return 0;
//}

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

istream& operator>>(istream& _cin, Date& d)
{
	_cin >> d._year;
	_cin >> d._month;
	_cin >> d._day;
	return _cin;
}

//int main()
//{
//	Date d;
//	cin >> d;
//	cout << d << endl;
//	return 0;
//}

//class A
//{
//private:
//	static int k;
//	int h;
//public:
//	class B // B天生就是A的友元
//	{
//	public:
//		void foo(const A& a)
//		{
//			cout << k << endl;//OK
//			cout << a.h << endl;//OK
//		}
//	};
//};
//int A::k = 1;
//int main()
//{
//	A::B b;
//	b.foo(A());
//
//	return 0;
//}

//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a;
//};
//
//class Solution 
//{
//public:
//	int Sum_Solution(int n) 
//	{
//		//...
//		return n;
//	}
//};
//
//int main()
//{
//	A aa1;
//	// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
//	//A aa1();
//	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
//	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
//	
//	A();
//	A aa2(2);
//	
//	// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
//	Solution().Sum_Solution(10);
//	return 0;
//}

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	} 
	
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

void f1(A aa)
{}

// A f2()
// {
// 	A aa;
// 	return aa;
// }

//int main()
//{
//	// 传值传参
//	A aa1;
//	f1(aa1);
//	cout << endl;
//	// 传值返回
//	f2();
//	cout << endl;
//	// 隐式类型，连续构造+拷贝构造->优化为直接构造
//	f1(1);
//	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
//	f1(A(2));
//	cout << endl;
//	// 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
//	A aa2 = f2();
//	cout << endl;
//	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
//	aa1 = f2();
//	cout << endl;
//	return 0;
//}


void Test()
{
	int* ptr4 = new int;
	int* ptr5 = new int(10);

	int* ptr6 = new int[3];
	
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};


//int main()
//{
//	A* p1 = (A*)malloc(sizeof(A));
//	A* p2 = new A();
//	free(p1);
//	delete p2;
//
//	int* p3 = (int*)malloc(sizeof(int));
//	int* p4 = new int;
//	free(p3);
//	delete p4;
//
//}

template<typename T>
void Swap(T& left, T& right)
{
	T tmp = left;
	left = right;
	right = tmp;
}


void Teststring()
{
	string s1;
	string s2("hello bit");
	string s4(s2);
}


void Test1()
{
	string s("hello C++");
	cout << s.size() << endl;
	cout << s.length() << endl;
	cout << s.capacity() << endl;
	cout << s << endl;

	s.clear();
	cout << s.size() << endl;
	cout << s.capacity() << endl;


	s.resize(10, 'a');
	cout << s << endl;
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	s.resize(15);
	cout << s << endl;
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	s.resize(5);
	cout << s << endl;
	cout << s.size() << endl;
	cout << s.capacity() << endl;
}

void Test2()
{
	string s;
	s.reserve(100);
	cout << s.size() << endl;
	cout << s.capacity() << endl;

	s.reserve(50);
	cout << s.size() << endl;
	cout << s.capacity() << endl;
}

void Test3()
{
	string s;
	size_t sz = s.capacity();
	cout << "making s grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

void Test4()
{
	string s;
	s.reserve(100);
	size_t sz = s.capacity();

	cout << "making s grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		s.push_back('c');
		if (sz != s.capacity())
		{
			sz = s.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

void Teststring3()
{
	string s1("hello Bit");
	const string s2("Hello Bit");
	cout << s1 << " " << s2 << endl;
	cout << s1[0] << " " << s2[0] << endl;

	s1[0] = 'H';
	cout << s1 << endl;

	// s2[0] = 'h';   代码编译失败，因为const类型对象不能修改
}

void Test5()
{
	string s("hello nihao");

	for (size_t i = 0; i < s.size(); i++)
		cout << s[i] << endl;
	cout << endl;

	string::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;

	auto rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit;
		rit++;
	}
	cout << endl;


	for (auto ch : s)
		cout << ch;
}

void Test6()
{
	/*string str;
	str.push_back(' ');
	str.append("hello");
	str += 'b';
	str += "it";
	cout << str << endl;
	cout << str.c_str() << endl;


	string file("string.cpp");
	size_t pos = file.rfind('.');
	string suffix(file.substr(pos, file.size() - pos));
	cout << suffix << endl;*/

	string url("http://www.cplusplus.com/reference/string/string/find/");
	cout << url << endl;
	size_t start = url.find("://");
	if (start == string::npos)
	{
		cout << "invalid url" << endl;
		return;
	}
	start += 3;
	size_t finish = url.find('/', start);
	string address = url.substr(start, finish - start);
	cout << address << endl;


	size_t pos = url.find("://");
	url.erase(0, pos + 3);
	cout << url << endl;
}

int main()
{
	//Test1();
	//Test2();
	//Test3();
	//Test4();
	//Teststring3();
	//Test5();
	Test6();
	return 0;
}

#include <string.h>
class String
{
public:
	String()
		:_data(new char[1])
	{
		*_data = '\0';
	}

	String(const char* str)
		:_data(new char[strlen(str) + 1])
	{
		strcpy(_data, str);
	}

	size_t size()const
	{
		return strlen(_data);
	}

	const char* c_str()const
	{
		return _data;
	}

	String(const String& rhs)
		:_data(new char[rhs.size() + 1])
	{
		strcpy(_data, rhs.c_str());
	}

	~String()
	{
		delete[] _data;
	}

	void swap(String& str)
	{
		std::swap(_data, str._data);
	}

	String& operator=(String str)
	{
		swap(str);
		return *this;
	}

	String(String&& str)
		:_data(str._data)
	{
		str._data = nullptr;
	}

	String operator=(String&& str)
	{
		swap(str);
		return *this;
	}
private:
	char* _data;
};



